Python Descriptor Protokolü: Özellik Erişim Kontrolü ve Veri Doğrulamada Uzmanlaşma

Python Descriptor Protokolü, sınıflarınızdaki nitelik erişimi ve değişikliği üzerinde hassas kontrol sağlayan güçlü, ancak genellikle yeterince kullanılmayan bir özelliktir. Karmaşık veri doğrulama ve özellik yönetimi uygulamak için bir yol sunarak daha temiz, daha sağlam ve bakımı daha kolay kodlara yol açar. Bu kapsamlı kılavuz, Descriptor Protokolü'nün inceliklerini, temel kavramlarını, pratik uygulamalarını ve en iyi uygulamalarını derinlemesine inceleyecektir.

Descriptor'ları Anlamak

Özünde, Descriptor Protokolü, bir nitelik descriptor adı verilen özel bir nesne türü olduğunda nitelik erişiminin nasıl ele alınacağını tanımlar. Descriptor'lar, aşağıdaki yöntemlerden bir veya daha fazlasını uygulayan sınıflardır:

• `__get__(self, instance, owner)`: Descriptor'ın değerine erişildiğinde çağrılır.
• `__set__(self, instance, value)`: Descriptor'ın değeri ayarlandığında çağrılır.
• `__delete__(self, instance)`: Descriptor'ın değeri silindiğinde çağrılır.

Bir sınıf örneğinin bir niteliği descriptor olduğunda, Python temeldeki niteliğe doğrudan erişmek yerine bu yöntemleri otomatik olarak çağırır. Bu araya girme mekanizması, özellik erişim kontrolü ve veri doğrulamanın temelini oluşturur.

Veri Descriptor'ları ve Veri Olmayan Descriptor'lar

Descriptor'lar ayrıca iki kategoriye ayrılır:

• Veri Descriptor'ları: Hem `__get__` hem de `__set__` yöntemlerini uygularlar (ve isteğe bağlı olarak `__delete__`). Aynı ada sahip örnek niteliklerine göre daha yüksek önceliğe sahiptirler. Bu, bir veri descriptor'ı olan bir niteliğe eriştiğinizde, örneğin aynı ada sahip bir niteliği olsa bile, her zaman descriptor'ın `__get__` yönteminin çağrılacağı anlamına gelir.
• Veri Olmayan Descriptor'lar: Yalnızca `__get__` yöntemini uygularlar. Örnek niteliklerine göre daha düşük önceliğe sahiptirler. Eğer örneğin aynı ada sahip bir niteliği varsa, descriptor'ın `__get__` yöntemi çağrılmak yerine bu nitelik döndürülür. Bu da onları salt okunur özellikler uygulamak gibi işler için kullanışlı kılar.

Temel fark, `__set__` yönteminin varlığında yatar. Bu yöntemin olmaması, bir descriptor'ı veri olmayan bir descriptor yapar.

Descriptor Kullanımının Pratik Örnekleri

Descriptor'ların gücünü birkaç pratik örnekle gösterelim.

Örnek 1: Tip Kontrolü

Belirli bir niteliğin her zaman belirli bir türde bir değer tuttuğundan emin olmak istediğinizi varsayalım. Descriptor'lar bu tür kısıtlamasını uygulayabilir:

class Typed:
    def __init__(self, name, expected_type):
        self.name = name
        self.expected_type = expected_type

    def __get__(self, instance, owner):
        if instance is None:
            return self  # Sınıfın kendisinden erişim
        return instance.__dict__[self.name]

    def __set__(self, instance, value):
        if not isinstance(value, self.expected_type):
            raise TypeError(f"Beklenen {self.expected_type}, alınan {type(value)}")
        instance.__dict__[self.name] = value

class Person:
    name = Typed('name', str)
    age = Typed('age', int)

    def __init__(self, name, age):
        self.name = name
        self.age = age

# Kullanım:
person = Person("Alice", 30)
print(person.name)  # Çıktı: Alice
print(person.age)   # Çıktı: 30

try:
    person.age = "thirty"
except TypeError as e:
    print(e) # Çıktı: Beklenen <class 'int'>, alınan <class 'str'>

Bu örnekte, `Typed` descriptor'ı `Person` sınıfının `name` ve `age` nitelikleri için tip kontrolü uygular. Yanlış türde bir değer atamaya çalışırsanız, bir `TypeError` hatası ortaya çıkar. Bu, veri bütünlüğünü artırır ve kodunuzun ilerleyen kısımlarında beklenmedik hataları önler.

Örnek 2: Veri Doğrulama

Tip kontrolünün ötesinde, descriptor'lar daha karmaşık veri doğrulamaları da yapabilir. Örneğin, sayısal bir değerin belirli bir aralıkta olduğundan emin olmak isteyebilirsiniz:

class Sized:
    def __init__(self, name, min_value, max_value):
        self.name = name
        self.min_value = min_value
        self.max_value = max_value

    def __get__(self, instance, owner):
        if instance is None:
            return self
        return instance.__dict__[self.name]

    def __set__(self, instance, value):
        if not isinstance(value, (int, float)):
            raise TypeError("Değer bir sayı olmalıdır")
        if not (self.min_value <= value <= self.max_value):
            raise ValueError(f"Değer {self.min_value} ile {self.max_value} arasında olmalıdır")
        instance.__dict__[self.name] = value

class Product:
    price = Sized('price', 0, 1000)

    def __init__(self, price):
        self.price = price

# Kullanım:
product = Product(99.99)
print(product.price) # Çıktı: 99.99

try:
    product.price = -10
except ValueError as e:
    print(e) # Çıktı: Değer 0 ile 1000 arasında olmalıdır

Burada, `Sized` descriptor'ı `Product` sınıfının `price` niteliğinin 0 ile 1000 aralığında bir sayı olduğunu doğrular. Bu, ürün fiyatının makul sınırlar içinde kalmasını sağlar.

Örnek 3: Salt Okunur Özellikler

Veri olmayan descriptor'lar kullanarak salt okunur özellikler oluşturabilirsiniz. Yalnızca `__get__` yöntemini tanımlayarak, kullanıcıların niteliği doğrudan değiştirmesini engellersiniz:

class ReadOnly:
    def __init__(self, name):
        self.name = name

    def __get__(self, instance, owner):
        if instance is None:
            return self
        return instance._private_value  # Özel bir niteliğe eriş

class Circle:
    radius = ReadOnly('radius')

    def __init__(self, radius):
        self._private_value = radius  # Değeri özel bir nitelikte sakla

# Kullanım:
circle = Circle(5)
print(circle.radius)  # Çıktı: 5

try:
    circle.radius = 10  # Bu, *yeni* bir örnek niteliği oluşturacaktır!
    print(circle.radius) # Çıktı: 10
    print(circle.__dict__) # Çıktı: {'_private_value': 5, 'radius': 10}
except AttributeError as e:
    print(e) # Bu tetiklenmeyecek çünkü yeni bir örnek niteliği descriptor'ı gölgeledi.

Bu senaryoda, `ReadOnly` descriptor'ı `Circle` sınıfının `radius` niteliğini salt okunur yapar. Doğrudan `circle.radius`'a atama yapmanın bir hata oluşturmadığına dikkat edin; bunun yerine, descriptor'ı gölgeleyen yeni bir örnek niteliği oluşturur. Atamayı gerçekten önlemek için `__set__` yöntemini uygulamanız ve bir `AttributeError` hatası fırlatmanız gerekir. Bu örnek, veri ve veri olmayan descriptor'lar arasındaki ince farkı ve ikincisiyle gölgelemenin nasıl meydana gelebileceğini gösterir.

Örnek 4: Gecikmeli Hesaplama (Tembel Değerlendirme)

Descriptor'lar, bir değerin yalnızca ilk erişildiğinde hesaplandığı tembel değerlendirmeyi uygulamak için de kullanılabilir:

import time

class LazyProperty:
    def __init__(self, func):
        self.func = func
        self.name = func.__name__

    def __get__(self, instance, owner):
        if instance is None:
            return self
        value = self.func(instance)
        instance.__dict__[self.name] = value  # Sonucu önbelleğe al
        return value

class DataProcessor:
    @LazyProperty
    def expensive_data(self):
        print("Pahalı veri hesaplanıyor...")
        time.sleep(2)  # Uzun bir hesaplamayı simüle et
        return [i for i in range(1000000)]

# Kullanım:
processor = DataProcessor()
print("Veriye ilk kez erişiliyor...")
start_time = time.time()
data = processor.expensive_data  # Bu, hesaplamayı tetikleyecektir
end_time = time.time()
print(f"İlk erişim için geçen süre: {end_time - start_time:.2f} saniye")

print("Veriye tekrar erişiliyor...")
start_time = time.time()
data = processor.expensive_data  # Bu, önbelleğe alınan değeri kullanacaktır
end_time = time.time()
print(f"İkinci erişim için geçen süre: {end_time - start_time:.2f} saniye")

`LazyProperty` descriptor'ı, `expensive_data` hesaplamasını ilk erişilene kadar geciktirir. Sonraki erişimler önbelleğe alınan sonucu alır ve performansı artırır. Bu desen, hesaplanması önemli kaynaklar gerektiren ve her zaman ihtiyaç duyulmayan nitelikler için kullanışlıdır.

İleri Düzey Descriptor Teknikleri

Temel örneklerin ötesinde, Descriptor Protokolü daha gelişmiş olanaklar sunar:

Descriptor'ları Birleştirme

Daha karmaşık özellik davranışları oluşturmak için descriptor'ları birleştirebilirsiniz. Örneğin, bir nitelik üzerinde hem tür hem de aralık kısıtlamalarını zorlamak için bir `Typed` descriptor'ını bir `Sized` descriptor'ı ile birleştirebilirsiniz.

class ValidatedProperty:
    def __init__(self, name, expected_type, min_value=None, max_value=None):
        self.name = name
        self.expected_type = expected_type
        self.min_value = min_value
        self.max_value = max_value

    def __get__(self, instance, owner):
        if instance is None:
            return self
        return instance.__dict__[self.name]

    def __set__(self, instance, value):
        if not isinstance(value, self.expected_type):
            raise TypeError(f"Beklenen {self.expected_type}, alınan {type(value)}")

        if self.min_value is not None and value < self.min_value:
            raise ValueError(f"Değer en az {self.min_value} olmalıdır")

        if self.max_value is not None and value > self.max_value:
            raise ValueError(f"Değer en fazla {self.max_value} olmalıdır")

        instance.__dict__[self.name] = value

class Employee:
    salary = ValidatedProperty('salary', int, min_value=0, max_value=1000000)

    def __init__(self, salary):
        self.salary = salary

# Örnek
employee = Employee(50000)
print(employee.salary)

try:
    employee.salary = -1000
except ValueError as e:
    print(e)

try:
    employee.salary = "abc"
except TypeError as e:
    print(e)

Descriptor'larla Metaclasses Kullanımı

Metaclasses, belirli kriterleri karşılayan bir sınıfın tüm niteliklerine otomatik olarak descriptor'lar uygulamak için kullanılabilir. Bu, standart kod miktarını önemli ölçüde azaltabilir ve sınıflarınız arasında tutarlılık sağlayabilir.

class DescriptorMetaclass(type):
    def __new__(cls, name, bases, attrs):
        for attr_name, attr_value in attrs.items():
            if isinstance(attr_value, Descriptor):
                attr_value.name = attr_name  # Nitelik adını descriptor'a enjekte et
        return super().__new__(cls, name, bases, attrs)

class Descriptor:
    def __get__(self, instance, owner):
        if instance is None:
            return self
        return instance.__dict__[self.name]

    def __set__(self, instance, value):
        instance.__dict__[self.name] = value

class UpperCase(Descriptor):
    def __set__(self, instance, value):
        if not isinstance(value, str):
            raise TypeError("Değer bir dize olmalıdır")
        instance.__dict__[self.name] = value.upper()

class MyClass(metaclass=DescriptorMetaclass):
    name = UpperCase()

# Örnek Kullanım:
obj = MyClass()
obj.name = "john doe"
print(obj.name)  # Çıktı: JOHN DOE

Descriptor Kullanımı İçin En İyi Uygulamalar

Descriptor Protokolü'nü etkili bir şekilde kullanmak için şu en iyi uygulamaları göz önünde bulundurun:

• Karmaşık mantığa sahip nitelikleri yönetmek için descriptor'ları kullanın: Descriptor'lar en çok, bir niteliğe erişirken veya onu değiştirirken kısıtlamalar uygulamanız, hesaplamalar yapmanız veya özel davranışlar uygulamanız gerektiğinde değerlidir.
• Descriptor'ları odaklanmış ve yeniden kullanılabilir tutun: Descriptor'ları belirli bir görevi yerine getirecek şekilde tasarlayın ve birden fazla sınıfta yeniden kullanılabilecek kadar genel hale getirin.
• Basit durumlar için alternatif olarak property() kullanmayı düşünün: Dahili `property()` fonksiyonu, temel getter, setter ve deleter yöntemlerini uygulamak için daha basit bir sözdizimi sağlar. Daha gelişmiş kontrol veya yeniden kullanılabilir mantığa ihtiyacınız olduğunda descriptor'ları kullanın.
• Performansa dikkat edin: Descriptor erişimi, doğrudan nitelik erişimine kıyasla ek yük getirebilir. Kodunuzun performansa duyarlı bölümlerinde descriptor'ların aşırı kullanımından kaçının.
• Açık ve açıklayıcı adlar kullanın: Descriptor'larınız için amaçlarını açıkça belirten adlar seçin.
• Descriptor'larınızı kapsamlı bir şekilde belgeleyin: Her bir descriptor'ın amacını ve nitelik erişimini nasıl etkilediğini açıklayın.

Global Hususlar ve Uluslararasılaştırma

Descriptor'ları global bir bağlamda kullanırken şu faktörleri göz önünde bulundurun:

• Veri doğrulama ve yerelleştirme: Veri doğrulama kurallarınızın farklı yerel ayarlara uygun olduğundan emin olun. Örneğin, tarih ve sayı formatları ülkelere göre değişir. Yerelleştirme desteği için `babel` gibi kütüphaneleri kullanmayı düşünün.
• Para birimi işlemleri: Parasal değerlerle çalışıyorsanız, farklı para birimlerini ve döviz kurlarını doğru bir şekilde işlemek için `moneyed` gibi bir kütüphane kullanın.
• Zaman dilimleri: Tarihler ve saatlerle uğraşırken zaman dilimlerinin farkında olun ve zaman dilimi dönüşümlerini yönetmek için `pytz` gibi kütüphaneleri kullanın.
• Karakter kodlaması: Kodunuzun, özellikle metin verileriyle çalışırken farklı karakter kodlamalarını doğru bir şekilde işlediğinden emin olun. UTF-8, yaygın olarak desteklenen bir kodlamadır.

Descriptor'lara Alternatifler

Descriptor'lar güçlü olsalar da her zaman en iyi çözüm değildirler. İşte göz önünde bulundurulması gereken bazı alternatifler:

• `property()`: Basit getter/setter mantığı için `property()` fonksiyonu daha kısa bir sözdizimi sunar.
• `__slots__`: Bellek kullanımını azaltmak ve dinamik nitelik oluşturulmasını önlemek istiyorsanız `__slots__` kullanın.
• Doğrulama kütüphaneleri: `marshmallow` gibi kütüphaneler, veri yapılarını tanımlamak ve doğrulamak için bildirimsel bir yol sunar.
• Dataclasses: Python 3.7+ sürümündeki dataclass'lar, `__init__`, `__repr__` ve `__eq__` gibi otomatik olarak oluşturulan yöntemlere sahip sınıfları tanımlamak için kısa ve öz bir yol sunar. Veri doğrulaması için descriptor'lar veya doğrulama kütüphaneleri ile birleştirilebilirler.

Sonuç

Python Descriptor Protokolü, sınıflarınızdaki nitelik erişimini ve veri doğrulamasını yönetmek için değerli bir araçtır. Temel kavramlarını ve en iyi uygulamalarını anlayarak daha temiz, daha sağlam ve bakımı daha kolay kodlar yazabilirsiniz. Descriptor'lar her nitelik için gerekli olmasa da, özellik erişimi ve veri bütünlüğü üzerinde hassas kontrol gerektiğinde vazgeçilmezdirler. Descriptor'ların faydalarını potansiyel ek yüklerine karşı tartmayı ve uygun olduğunda alternatif yaklaşımları göz önünde bulundurmayı unutmayın. Python programlama becerilerinizi yükseltmek ve daha karmaşık uygulamalar oluşturmak için descriptor'ların gücünü benimseyin.